home *** CD-ROM | disk | FTP | other *** search
/ Mac Easy 2010 May / Mac Life Ubuntu.iso / casper / filesystem.squashfs / usr / lib / python2.6 / xml / sax / expatreader.pyc (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2009-04-20  |  14.0 KB  |  411 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. """
  5. SAX driver for the pyexpat C module.  This driver works with
  6. pyexpat.__version__ == '2.22'.
  7. """
  8. version = '0.20'
  9. from xml.sax._exceptions import *
  10. from xml.sax.handler import feature_validation, feature_namespaces
  11. from xml.sax.handler import feature_namespace_prefixes
  12. from xml.sax.handler import feature_external_ges, feature_external_pes
  13. from xml.sax.handler import feature_string_interning
  14. from xml.sax.handler import property_xml_string, property_interning_dict
  15. import sys
  16. if sys.platform[:4] == 'java':
  17.     raise SAXReaderNotAvailable('expat not available in Java', None)
  18. sys.platform[:4] == 'java'
  19. del sys
  20.  
  21. try:
  22.     from xml.parsers import expat
  23. except ImportError:
  24.     raise SAXReaderNotAvailable('expat not supported', None)
  25.  
  26. if not hasattr(expat, 'ParserCreate'):
  27.     raise SAXReaderNotAvailable('expat not supported', None)
  28. not hasattr(expat, 'ParserCreate')
  29. from xml.sax import xmlreader, saxutils, handler
  30. AttributesImpl = xmlreader.AttributesImpl
  31. AttributesNSImpl = xmlreader.AttributesNSImpl
  32.  
  33. try:
  34.     import _weakref
  35. except ImportError:
  36.     
  37.     def _mkproxy(o):
  38.         return o
  39.  
  40.  
  41. import weakref
  42. _mkproxy = weakref.proxy
  43. del weakref
  44. del _weakref
  45.  
  46. class ExpatLocator(xmlreader.Locator):
  47.     '''Locator for use with the ExpatParser class.
  48.  
  49.     This uses a weak reference to the parser object to avoid creating
  50.     a circular reference between the parser and the content handler.
  51.     '''
  52.     
  53.     def __init__(self, parser):
  54.         self._ref = _mkproxy(parser)
  55.  
  56.     
  57.     def getColumnNumber(self):
  58.         parser = self._ref
  59.         if parser._parser is None:
  60.             return None
  61.         return parser._parser.ErrorColumnNumber
  62.  
  63.     
  64.     def getLineNumber(self):
  65.         parser = self._ref
  66.         if parser._parser is None:
  67.             return 1
  68.         return parser._parser.ErrorLineNumber
  69.  
  70.     
  71.     def getPublicId(self):
  72.         parser = self._ref
  73.         if parser is None:
  74.             return None
  75.         return parser._source.getPublicId()
  76.  
  77.     
  78.     def getSystemId(self):
  79.         parser = self._ref
  80.         if parser is None:
  81.             return None
  82.         return parser._source.getSystemId()
  83.  
  84.  
  85.  
  86. class ExpatParser(xmlreader.IncrementalParser, xmlreader.Locator):
  87.     '''SAX driver for the pyexpat C module.'''
  88.     
  89.     def __init__(self, namespaceHandling = 0, bufsize = 65516):
  90.         xmlreader.IncrementalParser.__init__(self, bufsize)
  91.         self._source = xmlreader.InputSource()
  92.         self._parser = None
  93.         self._namespaces = namespaceHandling
  94.         self._lex_handler_prop = None
  95.         self._parsing = 0
  96.         self._entity_stack = []
  97.         self._external_ges = 1
  98.         self._interning = None
  99.  
  100.     
  101.     def parse(self, source):
  102.         '''Parse an XML document from a URL or an InputSource.'''
  103.         source = saxutils.prepare_input_source(source)
  104.         self._source = source
  105.         self.reset()
  106.         self._cont_handler.setDocumentLocator(ExpatLocator(self))
  107.         xmlreader.IncrementalParser.parse(self, source)
  108.  
  109.     
  110.     def prepareParser(self, source):
  111.         if source.getSystemId() is not None:
  112.             self._parser.SetBase(source.getSystemId())
  113.         
  114.  
  115.     
  116.     def setContentHandler(self, handler):
  117.         xmlreader.IncrementalParser.setContentHandler(self, handler)
  118.         if self._parsing:
  119.             self._reset_cont_handler()
  120.         
  121.  
  122.     
  123.     def getFeature(self, name):
  124.         if name == feature_namespaces:
  125.             return self._namespaces
  126.         if name == feature_string_interning:
  127.             return self._interning is not None
  128.         if name in (feature_validation, feature_external_pes, feature_namespace_prefixes):
  129.             return 0
  130.         if name == feature_external_ges:
  131.             return self._external_ges
  132.         raise SAXNotRecognizedException("Feature '%s' not recognized" % name)
  133.  
  134.     
  135.     def setFeature(self, name, state):
  136.         if self._parsing:
  137.             raise SAXNotSupportedException('Cannot set features while parsing')
  138.         self._parsing
  139.         if name == feature_namespaces:
  140.             self._namespaces = state
  141.         elif name == feature_external_ges:
  142.             self._external_ges = state
  143.         elif name == feature_string_interning:
  144.             if state:
  145.                 if self._interning is None:
  146.                     self._interning = { }
  147.                 
  148.             else:
  149.                 self._interning = None
  150.         elif name == feature_validation:
  151.             if state:
  152.                 raise SAXNotSupportedException('expat does not support validation')
  153.             state
  154.         elif name == feature_external_pes:
  155.             if state:
  156.                 raise SAXNotSupportedException('expat does not read external parameter entities')
  157.             state
  158.         elif name == feature_namespace_prefixes:
  159.             if state:
  160.                 raise SAXNotSupportedException('expat does not report namespace prefixes')
  161.             state
  162.         else:
  163.             raise SAXNotRecognizedException("Feature '%s' not recognized" % name)
  164.         return name == feature_namespaces
  165.  
  166.     
  167.     def getProperty(self, name):
  168.         if name == handler.property_lexical_handler:
  169.             return self._lex_handler_prop
  170.         if name == property_interning_dict:
  171.             return self._interning
  172.         if name == property_xml_string:
  173.             if self._parser:
  174.                 if hasattr(self._parser, 'GetInputContext'):
  175.                     return self._parser.GetInputContext()
  176.                 raise SAXNotRecognizedException('This version of expat does not support getting the XML string')
  177.             self._parser
  178.             raise SAXNotSupportedException('XML string cannot be returned when not parsing')
  179.         name == property_xml_string
  180.         raise SAXNotRecognizedException("Property '%s' not recognized" % name)
  181.  
  182.     
  183.     def setProperty(self, name, value):
  184.         if name == handler.property_lexical_handler:
  185.             self._lex_handler_prop = value
  186.             if self._parsing:
  187.                 self._reset_lex_handler_prop()
  188.             
  189.         elif name == property_interning_dict:
  190.             self._interning = value
  191.         elif name == property_xml_string:
  192.             raise SAXNotSupportedException("Property '%s' cannot be set" % name)
  193.         else:
  194.             raise SAXNotRecognizedException("Property '%s' not recognized" % name)
  195.         return name == handler.property_lexical_handler
  196.  
  197.     
  198.     def feed(self, data, isFinal = 0):
  199.         if not self._parsing:
  200.             self.reset()
  201.             self._parsing = 1
  202.             self._cont_handler.startDocument()
  203.         
  204.         
  205.         try:
  206.             self._parser.Parse(data, isFinal)
  207.         except expat.error:
  208.             e = None
  209.             exc = SAXParseException(expat.ErrorString(e.code), e, self)
  210.             self._err_handler.fatalError(exc)
  211.  
  212.  
  213.     
  214.     def close(self):
  215.         if self._entity_stack:
  216.             return None
  217.         self.feed('', isFinal = 1)
  218.         self._cont_handler.endDocument()
  219.         self._parsing = 0
  220.         self._parser = None
  221.  
  222.     
  223.     def _reset_cont_handler(self):
  224.         self._parser.ProcessingInstructionHandler = self._cont_handler.processingInstruction
  225.         self._parser.CharacterDataHandler = self._cont_handler.characters
  226.  
  227.     
  228.     def _reset_lex_handler_prop(self):
  229.         lex = self._lex_handler_prop
  230.         parser = self._parser
  231.         if lex is None:
  232.             parser.CommentHandler = None
  233.             parser.StartCdataSectionHandler = None
  234.             parser.EndCdataSectionHandler = None
  235.             parser.StartDoctypeDeclHandler = None
  236.             parser.EndDoctypeDeclHandler = None
  237.         else:
  238.             parser.CommentHandler = lex.comment
  239.             parser.StartCdataSectionHandler = lex.startCDATA
  240.             parser.EndCdataSectionHandler = lex.endCDATA
  241.             parser.StartDoctypeDeclHandler = self.start_doctype_decl
  242.             parser.EndDoctypeDeclHandler = lex.endDTD
  243.  
  244.     
  245.     def reset(self):
  246.         if self._namespaces:
  247.             self._parser = expat.ParserCreate(self._source.getEncoding(), ' ', intern = self._interning)
  248.             self._parser.namespace_prefixes = 1
  249.             self._parser.StartElementHandler = self.start_element_ns
  250.             self._parser.EndElementHandler = self.end_element_ns
  251.         else:
  252.             self._parser = expat.ParserCreate(self._source.getEncoding(), intern = self._interning)
  253.             self._parser.StartElementHandler = self.start_element
  254.             self._parser.EndElementHandler = self.end_element
  255.         self._reset_cont_handler()
  256.         self._parser.UnparsedEntityDeclHandler = self.unparsed_entity_decl
  257.         self._parser.NotationDeclHandler = self.notation_decl
  258.         self._parser.StartNamespaceDeclHandler = self.start_namespace_decl
  259.         self._parser.EndNamespaceDeclHandler = self.end_namespace_decl
  260.         self._decl_handler_prop = None
  261.         if self._lex_handler_prop:
  262.             self._reset_lex_handler_prop()
  263.         
  264.         self._parser.ExternalEntityRefHandler = self.external_entity_ref
  265.         
  266.         try:
  267.             self._parser.SkippedEntityHandler = self.skipped_entity_handler
  268.         except AttributeError:
  269.             pass
  270.  
  271.         self._parser.SetParamEntityParsing(expat.XML_PARAM_ENTITY_PARSING_UNLESS_STANDALONE)
  272.         self._parsing = 0
  273.         self._entity_stack = []
  274.  
  275.     
  276.     def getColumnNumber(self):
  277.         if self._parser is None:
  278.             return None
  279.         return self._parser.ErrorColumnNumber
  280.  
  281.     
  282.     def getLineNumber(self):
  283.         if self._parser is None:
  284.             return 1
  285.         return self._parser.ErrorLineNumber
  286.  
  287.     
  288.     def getPublicId(self):
  289.         return self._source.getPublicId()
  290.  
  291.     
  292.     def getSystemId(self):
  293.         return self._source.getSystemId()
  294.  
  295.     
  296.     def start_element(self, name, attrs):
  297.         self._cont_handler.startElement(name, AttributesImpl(attrs))
  298.  
  299.     
  300.     def end_element(self, name):
  301.         self._cont_handler.endElement(name)
  302.  
  303.     
  304.     def start_element_ns(self, name, attrs):
  305.         pair = name.split()
  306.         if len(pair) == 1:
  307.             pair = (None, name)
  308.         elif len(pair) == 3:
  309.             pair = (pair[0], pair[1])
  310.         else:
  311.             pair = tuple(pair)
  312.         newattrs = { }
  313.         qnames = { }
  314.         for aname, value in attrs.items():
  315.             parts = aname.split()
  316.             length = len(parts)
  317.             if length == 1:
  318.                 qname = aname
  319.                 apair = (None, aname)
  320.             elif length == 3:
  321.                 qname = '%s:%s' % (parts[2], parts[1])
  322.                 apair = (parts[0], parts[1])
  323.             else:
  324.                 qname = parts[1]
  325.                 apair = tuple(parts)
  326.             newattrs[apair] = value
  327.             qnames[apair] = qname
  328.         
  329.         self._cont_handler.startElementNS(pair, None, AttributesNSImpl(newattrs, qnames))
  330.  
  331.     
  332.     def end_element_ns(self, name):
  333.         pair = name.split()
  334.         if len(pair) == 1:
  335.             pair = (None, name)
  336.         elif len(pair) == 3:
  337.             pair = (pair[0], pair[1])
  338.         else:
  339.             pair = tuple(pair)
  340.         self._cont_handler.endElementNS(pair, None)
  341.  
  342.     
  343.     def processing_instruction(self, target, data):
  344.         self._cont_handler.processingInstruction(target, data)
  345.  
  346.     
  347.     def character_data(self, data):
  348.         self._cont_handler.characters(data)
  349.  
  350.     
  351.     def start_namespace_decl(self, prefix, uri):
  352.         self._cont_handler.startPrefixMapping(prefix, uri)
  353.  
  354.     
  355.     def end_namespace_decl(self, prefix):
  356.         self._cont_handler.endPrefixMapping(prefix)
  357.  
  358.     
  359.     def start_doctype_decl(self, name, sysid, pubid, has_internal_subset):
  360.         self._lex_handler_prop.startDTD(name, pubid, sysid)
  361.  
  362.     
  363.     def unparsed_entity_decl(self, name, base, sysid, pubid, notation_name):
  364.         self._dtd_handler.unparsedEntityDecl(name, pubid, sysid, notation_name)
  365.  
  366.     
  367.     def notation_decl(self, name, base, sysid, pubid):
  368.         self._dtd_handler.notationDecl(name, pubid, sysid)
  369.  
  370.     
  371.     def external_entity_ref(self, context, base, sysid, pubid):
  372.         if not self._external_ges:
  373.             return 1
  374.         source = self._ent_handler.resolveEntity(pubid, sysid)
  375.         if not self._source.getSystemId():
  376.             pass
  377.         source = saxutils.prepare_input_source(source, '')
  378.         self._entity_stack.append((self._parser, self._source))
  379.         self._parser = self._parser.ExternalEntityParserCreate(context)
  380.         self._source = source
  381.         
  382.         try:
  383.             xmlreader.IncrementalParser.parse(self, source)
  384.         except:
  385.             self._external_ges
  386.             return 0
  387.  
  388.         (self._parser, self._source) = self._entity_stack[-1]
  389.         del self._entity_stack[-1]
  390.         return 1
  391.  
  392.     
  393.     def skipped_entity_handler(self, name, is_pe):
  394.         if is_pe:
  395.             name = '%' + name
  396.         
  397.         self._cont_handler.skippedEntity(name)
  398.  
  399.  
  400.  
  401. def create_parser(*args, **kwargs):
  402.     return ExpatParser(*args, **kwargs)
  403.  
  404. if __name__ == '__main__':
  405.     import xml.sax as xml
  406.     p = create_parser()
  407.     p.setContentHandler(xml.sax.XMLGenerator())
  408.     p.setErrorHandler(xml.sax.ErrorHandler())
  409.     p.parse('../../../hamlet.xml')
  410.  
  411.